/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package lector;

import org.junit.*;
import static org.junit.Assert.*;

/**
 *
 * @author carlossagastume
 */
public class PilaTest {
    
    public PilaTest() {
    }

    @BeforeClass
    public static void setUpClass() throws Exception {
    }

    @AfterClass
    public static void tearDownClass() throws Exception {
    }
    
    @Before
    public void setUp() {
    }
    
    @After
    public void tearDown() {
    }

    /**
     * Test of setPrueba method, of class Pila.
     */
    @Test
    public void testSetPrueba() {
        System.out.println("setPrueba");
        String prueba = "hola";
        Pila instance = new Pila (10);
        instance.setPrueba(prueba);
        // TODO review the generated test code and remove the default call to fail.
//        fail("The test case is a prototype.");
    }

    /**
     * Test of setInput1 method, of class Pila.
     */
    @Test
    public void testSetInput1() {
        System.out.println("setInput1");
        String[] input1 = new String[5];
        Pila instance = new Pila (5);
        instance.setInput1(input1);
        // TODO review the generated test code and remove the default call to fail.
//        fail("The test case is a prototype.");
    }

    /**
     * Test of setPrueba1 method, of class Pila.
     */
    @Test
    public void testSetPrueba1() {
        System.out.println("setPrueba1");
        boolean prueba1 = false;
        Pila instance = new Pila (10);
        instance.setPrueba1(prueba1);
        // TODO review the generated test code and remove the default call to fail.
//        fail("The test case is a prototype.");
    }

    /**
     * Test of setVector method, of class Pila.
     */
    @Test
    public void testSetVector() {
        System.out.println("setVector");
        Object[] vector = new Object[7];
        Pila instance = new Pila (10);
        instance.setVector(vector);
        // TODO review the generated test code and remove the default call to fail.
//        fail("The test case is a prototype.");
    }

    /**
     * Test of setJ method, of class Pila.
     */
    @Test
    public void testSetJ() {
        System.out.println("setJ");
        int j = 0;
        Pila instance = new Pila (10);
        instance.setJ(j);
        // TODO review the generated test code and remove the default call to fail.
//        fail("The test case is a prototype.");
    }

    /**
     * Test of setInput method, of class Pila.
     */
    @Test
    public void testSetInput() {
        System.out.println("setInput");
        int[] input = new int [5];
        Pila instance = new Pila (10);
        instance.setInput(input);
        // TODO review the generated test code and remove the default call to fail.
//        fail("The test case is a prototype.");
    }

    /**
     * Test of setOutput method, of class Pila.
     */
    @Test
    public void testSetOutput() {
        System.out.println("setOutput");
        int[] output = new int [10];
        Pila instance = new Pila (10);
        instance.setOutput(output);
        // TODO review the generated test code and remove the default call to fail.
//        fail("The test case is a prototype.");
    }

    /**
     * Test of setI method, of class Pila.
     */
    @Test
    public void testSetI() {
        System.out.println("setI");
        int i = 0;
        Pila instance = new Pila (10);
        instance.setI(i);
        // TODO review the generated test code and remove the default call to fail.
//        fail("The test case is a prototype.");
    }

    /**
     * Test of setO method, of class Pila.
     */
    @Test
    public void testSetO() {
        System.out.println("setO");
        int o = 0;
        Pila instance = new Pila (10);
        instance.setO(o);
        // TODO review the generated test code and remove the default call to fail.
//        fail("The test case is a prototype.");
    }

    /**
     * Test of setX method, of class Pila.
     */
    @Test
    public void testSetX() {
        System.out.println("setX");
        int x = 0;
        Pila instance = new Pila (10);
        instance.setX(x);
        // TODO review the generated test code and remove the default call to fail.
 //       fail("The test case is a prototype.");
    }

    /**
     * Test of setE method, of class Pila.
     */
    @Test
    public void testSetE() {
        System.out.println("setE");
        int e = 0;
        Pila instance = new Pila (10);
        instance.setE(e);
        // TODO review the generated test code and remove the default call to fail.
//        fail("The test case is a prototype.");
    }

    /**
     * Test of getPrueba method, of class Pila.
     */
    @Test
    public void testGetPrueba() {
        System.out.println("getPrueba");
        Pila instance = new Pila (10);
        Object expResult = null;
        Object result = instance.getPrueba();
        assertEquals(expResult, result);
        // TODO review the generated test code and remove the default call to fail.
 //       fail("The test case is a prototype.");
    }

    /**
     * Test of isPrueba1 method, of class Pila.
     */
    @Test
    public void testIsPrueba1() {
        System.out.println("isPrueba1");
        Pila instance = new Pila (10);
        boolean expResult = true;
        boolean result = instance.isPrueba1();
        assertEquals(expResult, result);
        // TODO review the generated test code and remove the default call to fail.
//        fail("The test case is a prototype.");
    }

    /**
     * Test of getVector method, of class Pila.
     */
    @Test
    public void testGetVector() {
        System.out.println("getVector");
        Pila instance = new Pila (10);
        Object[] expResult = new Object [10];
        Object[] result = instance.getVector();
        assertEquals(expResult, result);
        // TODO review the generated test code and remove the default call to fail.
//        fail("The test case is a prototype.");
    }

    /**
     * Test of getJ method, of class Pila.
     */
    @Test
    public void testGetJ() {
        System.out.println("getJ");
        Pila instance = new Pila (10);
        int expResult = 0;
        int result = instance.getJ();
        assertEquals(expResult, result);
        // TODO review the generated test code and remove the default call to fail.
//        fail("The test case is a prototype.");
    }

    /**
     * Test of getInput method, of class Pila.
     */
    @Test
    public void testGetInput() {
        System.out.println("getInput");
        Pila instance = new Pila (10);
        int[] hola = new int[5];
        instance.setInput(hola);
        int[] expResult = hola;
        int[] result = instance.getInput();
        assertEquals(expResult, result);
        // TODO review the generated test code and remove the default call to fail.
 //       fail("The test case is a prototype.");
    }

    /**
     * Test of getOutput method, of class Pila.
     */
    @Test
    public void testGetOutput() {
        System.out.println("getOutput");
        Pila instance = new Pila (10);
        int [] hola = new int [5];
        instance.setOutput(hola);
        int[] expResult = hola;
        int[] result = instance.getOutput();
        assertEquals(expResult, result);
        // TODO review the generated test code and remove the default call to fail.
 //       fail("The test case is a prototype.");
    }

    /**
     * Test of getI method, of class Pila.
     */
    @Test
    public void testGetI() {
        System.out.println("getI");
        Pila instance = new Pila (10);
        int expResult = 0;
        int result = instance.getI();
        assertEquals(expResult, result);
        // TODO review the generated test code and remove the default call to fail.
  //      fail("The test case is a prototype.");
    }

    /**
     * Test of getO method, of class Pila.
     */
    @Test
    public void testGetO() {
        System.out.println("getO");
        Pila instance = new Pila (10);
        int expResult = 0;
        int result = instance.getO();
        assertEquals(expResult, result);
        // TODO review the generated test code and remove the default call to fail.
 //       fail("The test case is a prototype.");
    }

    /**
     * Test of getX method, of class Pila.
     */
    @Test
    public void testGetX() {
        System.out.println("getX");
        Pila instance = new Pila (10);
        int expResult = 0;
        int result = instance.getX();
        assertEquals(expResult, result);
        // TODO review the generated test code and remove the default call to fail.
 //       fail("The test case is a prototype.");
    }

    /**
     * Test of getInput1 method, of class Pila.
     */
    @Test
    public void testGetInput1() {
        System.out.println("getInput1");
        Pila instance = new Pila (10);
        String[] expResult = new String [40];
        String[] result = instance.getInput1();
        assertEquals(expResult, result);
        // TODO review the generated test code and remove the default call to fail.
 //       fail("The test case is a prototype.");
    }

    /**
     * Test of Push method, of class Pila.
     */
    @Test
    public void testPush() {
        System.out.println("Push");
        char prueba = 'c';
        Pila instance = new Pila (10);
        instance.Push(prueba);
        // TODO review the generated test code and remove the default call to fail.
 //       fail("The test case is a prototype.");
    }

    /**
     * Test of Pop method, of class Pila.
     */
    @Test
    public void testPop() {
        System.out.println("Pop");
        char signo = '+';
        Pila instance = new Pila (10);
        instance.Pop(signo);
        // TODO review the generated test code and remove the default call to fail.
 //       fail("The test case is a prototype.");
    }

    /**
     * Test of Revisar method, of class Pila.
     */
    @Test
    public void testRevisar() {
        System.out.println("Revisar");
        Pila instance = new Pila (10);
        instance.Revisar();
        // TODO review the generated test code and remove the default call to fail.
  //      fail("The test case is a prototype.");
    }

    /**
     * Test of HasItems method, of class Pila.
     */
    @Test
    public void testHasItems() {
        System.out.println("HasItems");
        Pila instance = new Pila (10);
        boolean expResult = true;
        boolean result = instance.HasItems();
        assertEquals(expResult, result);
        // TODO review the generated test code and remove the default call to fail.
 //       fail("The test case is a prototype.");
    }
}
